// 获取年份集合
import * as echarts from 'echarts'
import "echarts-gl";
export const getYearRange = function (time1, time2) {
  return Array.from(
    { length: parseFloat(time2) - parseFloat(time1) + 1 },
    (_, i) => [`${parseFloat(time1) + i}年`, 0]
  );
}

export const formatNumber = function (num) {
  if (Number.isInteger(num)) {
    return num.toString(); // 整数直接返回字符串形式
  } else {
    return num.toFixed(2); // 小数保留 2 位
  }
}

function formatNumberText(num) {
  if (Number.isInteger(num)) {
    return num.toString(); // 整数直接返回字符串形式
  } else {
    return num.toFixed(2); // 小数保留 2 位
  }
}




// const { array1, array2 } = transformData(numberList);
// timeAndNumber = completeMissingTimes(time1, array1);
// timeAndNumber1 = completeMissingTimes(time1, array2);
// 分页大屏处理自定义天数数据
export const transforCheckDay = function (inputArray) {
  const array1 = []; // 格式: [ [日期, 数值1], ... ]
  const array2 = []; // 格式: [ [日期, 数值2], ... ]

  inputArray.forEach((item) => {
    const [date, value1, value2] = item;

    // 处理 null 值，若为 null 则转为 0
    const processedValue1 = value1 === null ? 0 : value1;
    const processedValue2 = value2 === null ? 0 : value2;

    // 存入 array1 和 array2
    array1.push([date, processedValue1]);
    array2.push([date, processedValue2]);

  });

  return { array1, array2 };
}


export const transforCheckDay1 = function (inputArray) {
  const array1 = []; // 格式: [ [日期, 数值1], ... ]
  const array2 = []; // 格式: [ [日期, 数值2], ... ]
  const array3 = []; // 格式: [ [日期, 数值2], ... ]
  inputArray.forEach((item) => {
    const [date, value1, value2, value3] = item;

    // 处理 null 值，若为 null 则转为 0
    const processedValue1 = value1 === null ? 0 : value1;
    const processedValue2 = value2 === null ? 0 : value2;
    const processedValue3 = value3 === null ? 0 : value3;
    // 存入 array1 和 array2
    array1.push([date, processedValue1]);
    array2.push([date, processedValue2]);
    array3.push([date, processedValue3]);
  });

  return { array1, array2, array3 };
}

// 分页大屏处理自定义月份
export const deilWithMonth = function (inputArray) {
  let array1 = [];
  let array2 = [];

  for (let item of inputArray) {
    // 处理第一个数值，null转为0
    let val1 = item[1] === null ? 0 : item[1];
    // 处理第二个数值，null转为0
    let val2 = item[2] === null ? 0 : item[2];

    // 格式化月份显示为"2025-06月"
    let month = item[0] + '月';

    array1.push([month, val1]);
    array2.push([month, val2]);
  }

  return [array1, array2];
}

export const deilWithMonth1 = function (inputArray) {
  let array1 = [];
  let array2 = [];
  let array3 = [];

  for (let item of inputArray) {
    // 处理第一个数值，null转为0
    let val1 = item[1] === null ? 0 : item[1];
    // 处理第二个数值，null转为0
    let val2 = item[2] === null ? 0 : item[2];
    let val3 = item[3] === null ? 0 : item[3];
    // 格式化月份显示为"2025-06月"
    let month = item[0] + '月';

    array1.push([month, val1]);
    array2.push([month, val2]);
    array3.push([month, val3]);
  }

  return [array1, array2, array3];
}
// 分页大屏处理自定义光伏月份
export const deilWithYear = function (inputArray) {
  let array1 = [];
  let array2 = [];

  for (let item of inputArray) {
    // 处理第一个数值，null转为0
    let val1 = item[1] === null ? 0 : item[1];
    // 处理第二个数值，null转为0
    let val2 = item[2] === null ? 0 : item[2];

    // 格式化月份显示为"2025-06月"
    let month = item[0] + '年'

    array1.push([month, val1]);
    array2.push([month, val2]);
  }

  return [array1, array2];
}

export const deilWithYear1 = function (inputArray) {
  let array1 = [];
  let array2 = [];
  let array3 = [];
  for (let item of inputArray) {
    // 处理第一个数值，null转为0
    let val1 = item[1] === null ? 0 : item[1];
    // 处理第二个数值，null转为0
    let val2 = item[2] === null ? 0 : item[2];
    let val3 = item[3] === null ? 0 : item[3];
    // 格式化月份显示为"2025-06月"
    let month = item[0] + '年'

    array1.push([month, val1]);
    array2.push([month, val2]);
    array3.push([month, val3]);
  }

  return [array1, array2, array3];
}



export const transformData = function (inputArray) {
  const array1 = []; // 格式: [ [年份第X周, 数值1], ... ]
  const array2 = []; // 格式: [ [年份第X周, 数值2], ... ]

  inputArray.forEach((item) => {
    const [yearWeek, value1, value2] = item;
    const year = yearWeek.substring(0, 4); // 提取年份（前4位）
    const week = yearWeek.substring(4);    // 提取周数（剩余部分）
    // 处理 null 值，若为 null 则转为 0
    const processedValue1 = value1 === null ? 0 : value1;
    const processedValue2 = value2 === null ? 0 : value2;

    // 构造 "2025第30周" 格式的字符串
    const weekLabel = `${year}第${week}周`;

    // 存入 array1 和 array2
    array1.push([weekLabel, processedValue1]);
    array2.push([weekLabel, processedValue2]);
  });

  return { array1, array2 };
}
export const transformData1 = function (inputArray) {
  const array1 = []; // 格式: [ [年份第X周, 数值1], ... ]
  const array2 = []; // 格式: [ [年份第X周, 数值2], ... ]
  const array3 = [];
  inputArray.forEach((item) => {
    const [yearWeek, value1, value2, value3] = item;
    const year = yearWeek.substring(0, 4); // 提取年份（前4位）
    const week = yearWeek.substring(4);    // 提取周数（剩余部分）
    // 处理 null 值，若为 null 则转为 0
    const processedValue1 = value1 === null ? 0 : value1;
    const processedValue2 = value2 === null ? 0 : value2;
    const processedValue3 = value3 === null ? 0 : value3;
    // 构造 "2025第30周" 格式的字符串
    const weekLabel = `${year}第${week}周`;

    // 存入 array1 和 array2
    array1.push([weekLabel, processedValue1]);
    array2.push([weekLabel, processedValue2]);
    array3.push([weekLabel, processedValue3]);
  });

  return { array1, array2, array3 };
}


// 获取月份集合
export const generateMonthRange = function (startYearMonth, endYearMonth) {
  const [startYear, startMonth] = startYearMonth.split("-").map(Number);
  const [endYear, endMonth] = endYearMonth.split("-").map(Number);

  const months = [];
  let currentYear = startYear;
  let currentMonth = startMonth;

  while (
    currentYear < endYear ||
    (currentYear === endYear && currentMonth <= endMonth)
  ) {
    // 格式化月份，确保两位数
    const formattedMonth = currentMonth.toString().padStart(2, "0");
    months.push([`${currentYear}-${formattedMonth}月`, 0]);

    // 移动到下个月
    currentMonth++;
    if (currentMonth > 12) {
      currentMonth = 1;
      currentYear++;
    }
  }

  return months;
}
// 获取天数集合
export const getDateRange = function (startDate, endDate) {
  console.log(startDate, endDate)
  const start = new Date(startDate);
  const end = new Date(endDate);

  // 验证日期有效性
  if (isNaN(start.getTime()) || isNaN(end.getTime())) {
    throw new Error("Invalid date format. Please use YYYY-MM-DD format.");
  }

  // 确保开始日期不大于结束日期
  if (start > end) {
    throw new Error("Start date must be before or equal to end date.");
  }

  const dateArray = [];
  let currentDate = new Date(start);

  while (currentDate <= end) {
    // 格式化为 YYYY-MM-DD
    const formattedDate = currentDate.toISOString().split("T")[0];
    dateArray.push([formattedDate, 0]);

    // 增加一天
    currentDate.setDate(currentDate.getDate() + 1);
  }

  return dateArray;
}
// 合并有空数据的数组
export const completeMissingTimes = function (baseArray, targetArray) {
  // 创建一个新数组来保存结果
  const resultArray = [];

  // 遍历基准数组（第一个数组）
  for (let i = 0; i < baseArray.length; i++) {
    const time = baseArray[i][0]; // 获取时间字符串，如 '0:00'

    // 在目标数组（第二个数组）中查找对应时间
    const foundItem = targetArray.find((item) => item[0] === time);

    if (foundItem) {
      // 如果找到，直接使用目标数组中的元素

      resultArray.push(foundItem);
    } else {
      // 如果没找到，创建一个新元素，格式为 [时间, '0']
      resultArray.push([time, 0, 0, 0]);
    }
  }

  return resultArray;
}
// 创建当天或者前一天的数据集合
export const getTodayArr = function (a) {
  const timeSlots = [];
  if (a == "1") {
    const now = new Date();
    const currentHours = now.getHours();
    const currentMinutes = now.getMinutes();

    // 创建今天的0:00时间
    const startTime = new Date();
    startTime.setHours(0, 0, 0, 0);

    while (startTime.getTime() <= now.getTime()) {
      const year = startTime.getFullYear();
      const hours = startTime.getHours().toString().padStart(2, "0");
      const minutes = startTime.getMinutes().toString().padStart(2, "0");
      timeSlots.push([`${hours}:${minutes}`, 0]);
      // 增加15分钟
      startTime.setMinutes(startTime.getMinutes() + 15);
    }
  } else if (a == "2") {
    for (let hour = 0; hour < 24; hour++) {
      for (let minute = 0; minute < 60; minute += 15) {
        // 格式化小时和分钟，确保两位数显示
        const formattedHour = hour.toString().padStart(2, "0");
        const formattedMinute = minute.toString().padStart(2, "0");

        // 创建时间字符串和时间条目
        const timeString = `${formattedHour}:${formattedMinute}`;
        timeSlots.push([timeString, 0]);
      }
    }
  } else if (a == 3) {
    const now = new Date();
    const currentHour = now.getHours().toString().padStart(2, '0');

    // 生成24小时数组
    const timeSlots = Array.from({ length: 24 }, (_, i) => {
      const hour = i.toString().padStart(2, '0');
      return [hour, hour === currentHour ? 0 : 0];
    });

    return timeSlots;
  } else if (a == 4) {
    const now = new Date();
    let hour = now.getHours()
    const currentHour = now.getHours().toString().padStart(2, '0');

    // 生成24小时数组
    const timeSlots = Array.from({ length: hour + 1 }, (_, i) => {
      const hour = i.toString().padStart(2, '0');
      return [hour, hour === currentHour ? 0 : 0];
    });

    return timeSlots;
  }
  return timeSlots;
}
export const getToday = function () {
  let date = new Date();
  let year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, "0");
  const day = String(date.getDate()).padStart(2, "0");

  return `${year}-${month}-${day}`;
}

export const getHourlyTimes = function (timeArray) {
  const arr = [];

  for (const item of timeArray) {
    const [time, value] = item;
    const hour = time.split(':')[1]; // 获取分钟部分

    if (minutes === '00') {
      arr.push([hour, value]); // 如果是整点，添加到结果数组
    }
  }

  return arr;
}


export const getDeviceTodayArr = function (a) {
  const timeSlots = [];
  if (a == "1") {
    const now = new Date();
    const currentHour = now.getHours();

    const hourlyArray = [];

    // 从0点到当前小时生成整点时间
    for (let hour = 0; hour <= currentHour; hour++) {
      // 格式化小时为两位数
      const formattedHour = hour.toString().padStart(2, '0');
      hourlyArray.push([`${formattedHour}`, 0]);
    }

    return hourlyArray;
  } else if (a == "2") {
    for (let hour = 0; hour < 24; hour++) {

      // 格式化小时和分钟，确保两位数显示
      const formattedHour = hour.toString();


      // 创建时间字符串和时间条目
      const timeString = `${formattedHour}`;
      timeSlots.push([timeString, 0]);
    }
  }
  return timeSlots;
}



export const createAverageArray = function (dataArray) {
  // 第一步：计算总和和有效项数
  let sum = 0;
  let count = 0;

  dataArray.forEach(item => {
    const value = item;

    if (value === null) {
      sum += 0;  // null视为0
      count++;
    } else if (typeof value === 'string') {
      const num = parseFloat(value);
      sum += isNaN(num) ? 0 : num;  // 无效数字视为0
      count++;
    } else if (typeof value === 'number') {
      sum += value;
      count++;
    }
  });

  // 第二步：计算平均值
  let average = count > 0 ? sum / count : 0;
  average = formatNumberText(average)
  // 第三步：创建平均值数组（长度与原数组相同）
  const averageArray = new Array(dataArray.length).fill(average);

  return averageArray
}
export const transformHourlyDataWithDecimal = function (originalArray) {
  return originalArray.map(item => {
    const hourPart = item[0].split(' ')[1];

    let value = item[1] === null || item[1] === "0.0" ? 0 : parseFloat(item[1]);
    if (value < 0) {
      value = 0
    }
    return [hourPart, value];
  });
}
// 传入的两个周进行格式化补全
export const generateWeekRange = function (startStr, endStr) {
  // 解析周字符串
  const parseWeek = (str) => {
    const [year, week] = str.split('-').map(Number);
    if (isNaN(year) || isNaN(week) || week < 1 || week > 53) {
      throw new Error(`无效的周数格式: ${str}`);
    }
    return { year, week };
  };

  const start = parseWeek(startStr);
  const end = parseWeek(endStr);

  // 验证时间顺序
  if (start.year > end.year || (start.year === end.year && start.week > end.week)) {
    throw new Error('开始周不能晚于结束周');
  }

  const result = [];
  let currentYear = start.year;
  let currentWeek = start.week;

  // 生成周数范围
  while (currentYear < end.year || (currentYear === end.year && currentWeek <= end.week)) {
    result.push([`${currentYear}第${currentWeek.toString().padStart(2, '0')}周`, 0]);

    currentWeek++;
    if (currentWeek > 52) {  // 一年最多52周
      currentYear++;
      currentWeek = 1;
    }
  }

  return result;
}

// 将获取的数据进行格式化
export const formatNumberList = function (dataArray) {
  return dataArray.map(([weekStr, value, value1]) => {
    const match = weekStr.match(/^(\d{4})(\d{2})$/);

    if (!match) {
      throw new Error(`数据格式不正确: ${weekStr}`);
    }

    const year = match[1];
    const weekNumber = parseInt(match[2], 10);

    if (weekNumber < 1 || weekNumber > 53) {
      throw new Error(`周数 ${weekNumber} 无效（应在1-53之间）`);
    }

    return [`${year}第${weekNumber}周`, value];
  });
}



export const extractUniqueTypes = function (dataArray) {
  const uniqueTypes = []; // 存储唯一type值的数组

  // 遍历数组中的每个元素
  dataArray.forEach(item => {
    // 检查当前元素的type是否存在且不在uniqueTypes中
    if (item.type !== undefined && item.type !== null &&
      !uniqueTypes.includes(item.type)) {
      uniqueTypes.push(item.type); // 添加到结果数组
    }
  });

  return uniqueTypes;
}











export const
  deviceBar = {
    tooltip: {
      trigger: "axis",
    },

    // 图例配置
    legend: {
      data: ["电力", "设定值", "均值"],
      top: 0,
      left: "3%",
      itemWidth: 20,
      // 单个图例项的图标高度
      itemHeight: 12,
      textStyle: {
        color: "white", // 设置为红色
        // 还可以设置其他文字样式
        fontSize: 12,
        fontWeight: "bold",
      },
    },

    // 网格配置
    grid: {
      left: "3%",
      right: "10%",
      bottom: "5%",
      top: "20%",
      containLabel: true,
    },

    // X轴配置
    xAxis: [
      {
        type: "category",
        name: "时间(小时)",
        nameTextStyle: {
          color: "white",
        },
        axisTick: {
          show: false,
        },

        data: [
          '01'
        ],
        axisLabel: {
          color: "white", // 设置为红色
          fontSize: 12, // 字体大小
          fontWeight: "bold", // 字体粗细
        },

      },
    ],

    // Y轴配置（双Y轴）
    yAxis: [
      {
        type: "value",
        min: 0,
        name: "t",
        nameTextStyle: {
          color: "white",
          fontSize: 12,
        },
        axisLabel: {
          formatter: "{value}",
        },
        splitLine: {
          show: false,
        },
        axisLine: {
          show: true,
          lineStyle: {
            color: "white",
          },
        },
      },
    ],

    // 系列配置
    series: [
      // 柱状图系列（销量）
      {
        name: "电力",
        type: "bar",
        barWidth: "30%",
        data: [],
        itemStyle: {
          color: "#84CE30",
        },
      },

      // 第一条折线图（完成率）
      {
        name: "设定值",
        type: "line",
        data: [],
        itemStyle: {
          color: "#00FFF8",
        },
        symbol: "circle",
        symbolSize: 0,
        lineStyle: {
          width: 3,
        },
      },

      {
        name: "均值",
        type: "line",

        data: [],
        itemStyle: {
          color: "#EE6666",
        },
        symbolSize: 0,
        lineStyle: {
          width: 3,
        },
      },
    ],
  }



var data = [
  { name: '满意', value: 30, itemStyle: { color: '#c045ed' }, startRatio: 0, endRatio: 0.7 },
  { name: '非常满意', value: 45, itemStyle: { color: '#6442ee' }, startRatio: 0.7, endRatio: 1 },
  { name: '满意', value: 6, itemStyle: { color: '#3556ee' }, startRatio: 0.7, endRatio: 1 },
  { name: '基本满意', value: 14, itemStyle: { color: '#82cbe4' }, startRatio: 0.7, endRatio: 1 },
  { name: '不满意', value: 5, itemStyle: { color: '#56c0f4' }, startRatio: 0.7, endRatio: 1 },
];

// export const init3dChart = function (element, data) {
//   const chart = echarts.init(element);

//   var data = data;

//   const getPie3D = (pieData, internalDiameterRatio) => {
//     //internalDiameterRatio:透明的空心占比
//     let series = [];
//     let sumValue = 0;
//     let startValue = 0;
//     let endValue = 0;
//     let k = 1;
//     pieData.sort((a, b) => {
//       return b.value - a.value;
//     });
//     // 为每一个饼图数据，生成一个 series-surface 配置
//     for (let i = 0; i < pieData.length; i++) {
//       sumValue += pieData[i].value;
//       let seriesItem = {
//         name:
//           typeof pieData[i].name === "undefined"
//             ? `series${i}`
//             : pieData[i].name,
//         type: "surface",
//         parametric: true,
//         wireframe: {
//           show: false,
//         },
//         pieData: pieData[i],
//         pieStatus: {
//           selected: false,
//           hovered: false,
//           k: k,
//         },
//         radius: "50%",
//         center: ["20%", "30%"],
//       };

//       if (typeof pieData[i].itemStyle != "undefined") {
//         let itemStyle = {};
//         typeof pieData[i].itemStyle.color != "undefined"
//           ? (itemStyle.color = pieData[i].itemStyle.color)
//           : null;
//         typeof pieData[i].itemStyle.opacity != "undefined"
//           ? (itemStyle.opacity = pieData[i].itemStyle.opacity)
//           : null;
//         seriesItem.itemStyle = itemStyle;
//       }
//       series.push(seriesItem);
//     }

//     // 使用上一次遍历时，计算出的数据和 sumValue，调用 getParametricEquation 函数，
//     // 向每个 series-surface 传入不同的参数方程 series-surface.parametricEquation，也就是实现每一个扇形。

//     for (let i = 0; i < series.length; i++) {
//       endValue = startValue + series[i].pieData.value;
//       series[i].pieData.startRatio = startValue / sumValue;
//       series[i].pieData.endRatio = endValue / sumValue;
//       series[i].parametricEquation = getParametricEquation(
//         series[i].pieData.startRatio,
//         series[i].pieData.endRatio,
//         false,
//         false,
//         k,
//         series[i].pieData.value
//       );
//       startValue = endValue;
//     }
//     let boxHeight = getHeight3D(series, 25); //通过传参设定3d饼/环的高度，26代表26px
//     // 准备待返回的配置项，把准备好的 legendData、series 传入。
//     let option = {
//       // backgroundColor: "#203598",
//       legend: {
//         // 新增图例配置
//         show: true,
//         orient: "horizontal",
//         left: "center",
//         itemWidth: 20,
//         // 单个图例项的图标高度
//         itemHeight: 12,
//         bottom: 0,
//         textStyle: {
//           color: "white",
//           fontSize: 12,
//           fontFamily: 'mei'
//         },
//         data: data.map((item) => item.name), // 使用数据中的name作为图例
//       },
//       labelLine: {
//         show: false,
//         lineStyle: {
//           color: "#404772",
//         },
//       },
//       label: {
//         show: false,
//         type: "surface",
//         // 确保与 2D 饼图一致
//         pieData: {
//           startAngle: -25, // 与 2D 饼图相同
//           clockwise: false, // 与 2D 饼图相同
//         },
//         formatter: "{b|{b}}\n{c|{c}%}",
//       },
//       tooltip: {
//         backgroundColor: "#053A8D",
//         formatter: (params) => {
//           if (
//             params.seriesName !== "mouseoutSeries" &&
//             params.seriesName !== "pie2d"
//           ) {
//             let bfb = (
//               (option.series[params.seriesIndex].pieData.endRatio -
//                 option.series[params.seriesIndex].pieData.startRatio) *
//               100
//             ).toFixed(2);
//             return (
//               `${params.seriesName}<br/>` +
//               `<span style="display:inline-block;margin-right:5px;border-radius:10px;width:10px;height:10px;background-color:${params.color};"></span>` +
//               `${bfb}%`
//             );
//           }
//         },
//       },
//       xAxis3D: {
//         min: -1,
//         max: 1,
//       },
//       yAxis3D: {
//         min: -1,
//         max: 1,
//       },
//       zAxis3D: {
//         min: -1,
//         max: 1,
//       },
//       grid3D: {
//         show: false,
//         boxHeight: boxHeight, //圆环的高度
//         left: 0,
//         top: 0, //3d饼图的位置
//         viewControl: {
//           //3d效果可以放大、旋转等，请自己去查看官方配置
//           alpha: 20, //角度
//           distance: 250, //调整视角到主体的距离，类似调整zoom
//           rotateSensitivity: 0, //设置为0无法旋转
//           zoomSensitivity: 0, //设置为0无法缩放
//           panSensitivity: 0, //设置为0无法平移
//           autoRotate: false, //自动旋转
//         },
//       },
//       series: series,
//     };
//     return option;
//   };

//   //获取3d丙图的最高扇区的高度
//   const getHeight3D = (series, height) => {
//     series.sort((a, b) => {
//       return b.pieData.value - a.pieData.value;
//     });
//     return (height * 25) / series[0].pieData.value;
//   };

//   // 生成扇形的曲面参数方程，用于 series-surface.parametricEquation
//   const getParametricEquation = (
//     startRatio,
//     endRatio,
//     isSelected,
//     isHovered,
//     k,
//     h
//   ) => {
//     // 计算
//     let midRatio = (startRatio + endRatio) / 2;
//     let startRadian = startRatio * Math.PI * 2;
//     let endRadian = endRatio * Math.PI * 2;
//     let midRadian = midRatio * Math.PI * 2;
//     // 如果只有一个扇形，则不实现选中效果。
//     if (startRatio === 0 && endRatio === 1) {
//       isSelected = true;
//     }
//     // 通过扇形内径/外径的值，换算出辅助参数 k（默认值 1/3）
//     k = typeof k !== "undefined" ? k : 1 / 3;
//     // 计算选中效果分别在 x 轴、y 轴方向上的位移（未选中，则位移均为 0）
//     let offsetX = isSelected ? Math.cos(midRadian) * 0.1 : 0;
//     let offsetY = isSelected ? Math.sin(midRadian) * 0.1 : 0;
//     // 计算高亮效果的放大比例（未高亮，则比例为 1）
//     let hoverRate = isHovered ? 1.05 : 1;
//     // 返回曲面参数方程
//     return {
//       u: {
//         min: -Math.PI,
//         max: Math.PI * 3,
//         step: Math.PI / 32,
//       },
//       v: {
//         min: 0,
//         max: Math.PI * 2,
//         step: Math.PI / 20,
//       },
//       x: function (u, v) {
//         if (u < startRadian) {
//           return (
//             offsetX +
//             Math.cos(startRadian) * (1 + Math.cos(v) * k) * hoverRate
//           );
//         }
//         if (u > endRadian) {
//           return (
//             offsetX +
//             Math.cos(endRadian) * (1 + Math.cos(v) * k) * hoverRate
//           );
//         }
//         return offsetX + Math.cos(u) * (1 + Math.cos(v) * k) * hoverRate;
//       },
//       y: function (u, v) {
//         if (u < startRadian) {
//           return (
//             offsetY +
//             Math.sin(startRadian) * (1 + Math.cos(v) * k) * hoverRate
//           );
//         }
//         if (u > endRadian) {
//           return (
//             offsetY +
//             Math.sin(endRadian) * (1 + Math.cos(v) * k) * hoverRate
//           );
//         }
//         return offsetY + Math.sin(u) * (1 + Math.cos(v) * k) * hoverRate;
//       },
//       z: function (u, v) {
//         if (u < -Math.PI * 0.5) {
//           return Math.sin(u);
//         }
//         if (u > Math.PI * 2.5) {
//           return Math.sin(u) * h * 0.1;
//         }
//         return Math.sin(v) > 0 ? 1 * h * 0.1 : -1;
//       },
//     };
//   };

//   let option = getPie3D(data, 0.8);
//   option.grid3D.top = -30;
//   option.series.push({
//     name: "pie2d",
//     type: "pie",
//     label: {
//       show: false,
//       position: "inside", // 关键修改：标签显示在扇形内部
//       formatter: (params) => {
//         const percent = (
//           ((params.endAngle - params.startAngle) / 360) *
//           100
//         ).toFixed(2);
//         return `{name|${params.name}}`; // 分行显示
//       },
//       rich: {
//         name: {
//           fontSize: 12,
//           color: "#fff",
//           fontWeight: "bold",
//           align: "center",
//         },
//         percent: {
//           fontSize: 10,
//           color: "rgba(255,255,255,0.8)",
//           align: "center",
//         },
//       },
//       // 移除引导线（内部标签不需要）
//       labelLine: {
//         show: false,
//       },
//     },
//     startAngle: -25, //起始角度，支持范围[0, 360]。
//     clockwise: false, //饼图的扇区是否是顺时针排布。上述这两项配置主要是为了对齐3d的样式
//     radius: ["65%", "65%"],
//     center: ["55%", "40%"], //指示线的位置
//     data: data,
//     itemStyle: {
//       opacity: 0,
//     },
//   });

//   chart.setOption(option);
// }


// 处理单设备电力单天数据
export const processData = function (inputData) {
  return inputData.map(item => {
    // 提取小时部分
    const hour = item[0].split(' ')[1];
    // 处理第二个元素，如果为null则设为0
    const value = item[1] === null ? 0 : item[1];
    // 返回新数组，忽略第三个元素
    return [hour, value];
  });
}


// 处理光伏单个设备天的数据
export const processGuangFuDayHour = function (inputData) {
  const array1 = []; // 格式: [小时, 第二个元素]
  const array2 = []; // 格式: [小时, 第三个元素]
  const array3 = [];
  inputData.forEach(item => {
    // 提取小时部分
    const hour = item[0].split(' ')[1];

    // 处理第二个元素，如果为null则设为0
    const value1 = item[1] === null ? 0 : item[1];
    // 处理第三个元素，如果为null则设为0
    const value2 = item[2] === null ? 0 : item[2];
    const value3 = item[2] === null ? 0 : item[3];

    console.log('value3', value3)
    array1.push([hour + ':00', value1]);
    array2.push([hour + ':00', value2]);
    array3.push([hour + ':00', value3]);
  });

  return [array1, array2, array3];
}
export const processGuangFuDayHour1 = function (inputData) {
  const array1 = []; // 格式: [小时, 第二个元素]
  const array2 = []; // 格式: [小时, 第三个元素]

  inputData.forEach(item => {
    // 提取小时部分
    const hour = item[0].split(' ')[1];

    // 处理第二个元素，如果为null则设为0
    const value1 = item[1] === null ? 0 : item[1];
    // 处理第三个元素，如果为null则设为0
    const value2 = item[2] === null ? 0 : item[2];

    array1.push([hour, value1]);
    array2.push([hour, value2]);
  });

  return [array1, array2];
}

// 处理光伏设备求平均值
export const calculateGuangFuAverage = function (arr1, arr2) {
  // 检查数组长度是否一致
  if (arr1.length !== arr2.length) {
    throw new Error("两个数组长度不一致");
  }

  // 计算总和
  let sum = 0;
  for (let i = 0; i < arr1.length; i++) {
    const val1 = arr1[i] === null ? 0 : arr1[i];
    const val2 = arr2[i] === null ? 0 : arr2[i];
    sum += val1 + val2;
  }

  // 计算平均值：总和/(两个数组的长度和)
  // 因为两个数组长度相同，所以相当于 sum/(2*arr1.length)
  const average = formatNumberText(parseFloat((sum / (2 * arr1.length))));

  // 创建结果数组，所有元素都是这个平均值
  const result = new Array(arr1.length).fill(Number(average));

  return result;
}


export const option4Line = {
  tooltip: {
    trigger: "axis",
  },
  legend: {
    data: ["用电量", "上网电量"],
    top: 0,
    left: "center",
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    textStyle: {
      fontFamily: "mei",
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
      fontWeight: "bold",
    },
  },
  // 网格配置
  grid: {
    left: "1%",
    right: "10%",
    bottom: "8%",
    top: "21%",
    containLabel: true,
  },

  // X轴配置
  xAxis: [
    {
      type: "category",
      name: "时间",
      nameTextStyle: {
        color: "white",
        fontFamily: "mei",
        fontSize: 12,
      },
      axisTick: {
        show: false,
      },
      axisLine: {
        show: true,
        lineStyle: {
          color: "#5D6A94",
        },
      },
      axisLabel: {
        show: true,
        color: "white", // 设置为红色
        fontSize: 12, // 字体大小
        fontFamily: "mei",
        // 字体粗细
      },
      data: [],

    },
  ],

  // Y轴配置（双Y轴）
  yAxis: [
    {
      name: "光伏",
      nameTextStyle: {
        color: "white",
        fontFamily: "mei",
        fontSize: 12,
      },
      type: "value",
      min: 0,
      axisLabel: {
        formatter: "{value}",
        fontFamily: "mei",
        color: "white",
      },
      splitLine: {
        show: false,
      },
      axisLine: {
        show: true,
        lineStyle: {
          color: "#5D6A94",
        },
      },
    },
  ],

  // 系列配置
  series: [
    // 柱状图系列（销量）
    {
      type: "line",
      symbol: "circle",
      symbolSize: 0,
      name: "用电量",
      // barWidth: "30%",
      data: [],
      itemStyle: {
        color: "#19A3DF",
        borderColor: "white", // 边框颜色
        borderWidth: 2, // 边框宽度
        borderType: "solid",
      },
      lineStyle: {
        color: "#19A3DF",
      },
      label: {
        show: false,
        color: "#FFBF28",
      },
      areaStyle: {
        //区域填充样式
        normal: {
          color: new echarts.graphic.LinearGradient(
            0,
            0,
            0,
            1,
            [
              {
                offset: 0,
                color: "rgba(25,163,223,.3)",
              },
              {
                offset: 1,
                color: "rgba(25,163,223, 0)",
              },
            ],
            false
          ),
          shadowColor: "rgba(25,163,223, 0.5)", //阴影颜色
          shadowBlur: 20,
        },
      },
      smooth: true,
    },
    {
      type: "line",
      symbol: "circle",
      symbolSize: 0,
      name: "上网电量",
      // barWidth: "30%",
      data: [],
      itemStyle: {
        color: "#78B029",
        borderColor: "white", // 边框颜色
        borderWidth: 2, // 边框宽度
        borderType: "solid",
      },
      lineStyle: {
        color: "#78B029",
      },
      label: {
        show: false,

      },
      areaStyle: {
        //区域填充样式
        normal: {
          color: new echarts.graphic.LinearGradient(
            0,
            0,
            0,
            1,
            [
              {
                offset: 0,
                color: "rgba(25,163,223,.3)",
              },
              {
                offset: 1,
                color: "rgba(25,163,223, 0)",
              },
            ],
            false
          ),
          shadowColor: "rgba(25,163,223, 0.5)", //阴影颜色
          shadowBlur: 20,
        },
      },
      smooth: true,
    },
  ],
}


export const option4GuangBar = {

  tooltip: {
    trigger: "item",
  },

  // 图例配置
  legend: {
    data: ["光伏1", "光伏2"],
    top: 0,
    left: 0,
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    textStyle: {
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
      fontWeight: "bold",
    },
  },

  // 网格配置
  grid: {
    left: "3%",
    right: "8%",
    bottom: "8%",
    top: "20%",
    containLabel: true,
  },

  // X轴配置
  xAxis: [
    {
      type: "category",
      name: "时间",
      nameTextStyle: {
        color: "white",
      },
      axisTick: {
        show: false,
      },
      axisLine: {
        show: true,
        lineStyle: {
          color: "#5D6A94",
        },
      },
      axisLabel: {
        color: "white", // 设置为红色
        fontSize: 12, // 字体大小
        fontWeight: "bold", // 字体粗细
      },
      data: [

      ],

    },
  ],

  // Y轴配置（双Y轴）
  yAxis: [
    {
      type: "value",
      min: 0,
      axisLabel: {
        formatter: "{value}",
      },
      splitLine: {
        show: false,
      },
      axisLine: {
        show: true,
        lineStyle: {
          color: "#5D6A94",
        },
      },
      axisLabel: {
        color: "white", // 设置为红色
        fontSize: 12, // 字体大小
      },
    },
  ],

  // 系列配置
  series: [
    // 柱状图系列（销量）
    {
      name: "光伏1",
      type: "line",
      symbol: "circle",
      symbolSize: 0,
      // barWidth: "30%",
      data: [],
      itemStyle: {
        color: "#78B029",
        borderColor: "white", // 边框颜色
        borderWidth: 2, // 边框宽度
        borderType: "solid",
      },
      lineStyle: {
        color: "#78B029",
      },
      label: {
        show: false,
        color: "#FFBF28",
      },
      areaStyle: {
        //区域填充样式
        normal: {
          color: new echarts.graphic.LinearGradient(
            0,
            0,
            0,
            1,
            [
              {
                offset: 0,
                color: "rgba(25,163,223,.3)",
              },
              {
                offset: 1,
                color: "rgba(25,163,223, 0)",
              },
            ],
            false
          ),
          shadowColor: "rgba(25,163,223, 0.5)", //阴影颜色
          shadowBlur: 20,
        },
      },
      smooth: true,
    },
    {
      name: "光伏2",
      type: "line",
      symbol: "circle",
      symbolSize: 0,
      // barWidth: "30%",
      data: [],
      itemStyle: {
        color: "#19A3DF",
        borderColor: "white", // 边框颜色
        borderWidth: 2, // 边框宽度
        borderType: "solid",
      },
      lineStyle: {
        color: "#19A3DF",
      },
      label: {
        show: false,
        color: "#FFBF28",
      },
      areaStyle: {
        //区域填充样式
        normal: {
          color: new echarts.graphic.LinearGradient(
            0,
            0,
            0,
            1,
            [
              {
                offset: 0,
                color: "rgba(25,163,223,.3)",
              },
              {
                offset: 1,
                color: "rgba(25,163,223, 0)",
              },
            ],
            false
          ),
          shadowColor: "rgba(25,163,223, 0.5)", //阴影颜色
          shadowBlur: 20,
        },
      },
      smooth: true,
    },
  ],

}


export const firstCityWeek = function (startWeekStr, endWeekStr) {
  // 解析起始年和周数
  const [startYear, startWeek] = startWeekStr.split('-').map(Number);
  const [endYear, endWeek] = endWeekStr.split('-').map(Number);

  const result = [];

  // 计算总周数
  const totalWeeks = (endYear - startYear) * 52 + (endWeek - startWeek) + 1;

  let currentYear = startYear;
  let currentWeek = startWeek;

  for (let i = 0; i < totalWeeks; i++) {
    // 格式化周数为两位数
    const formattedWeek = currentWeek.toString().padStart(2, '0');
    result.push([`${currentYear}第${formattedWeek}周`, 0]);

    // 移动到下一周
    currentWeek++;

    // 检查是否需要跨年
    if (currentWeek > 52) {
      currentWeek = 1;
      currentYear++;
    }
  }

  return result;
}


export const getChooseTime = function (text) {
  let timeDate = null
  if (text == "天") {
    timeDate = 1;
  } else if (text == "周") {
    timeDate = 2;
  } else if (text == "月") {
    timeDate = 3;
  } else if (text == "年") {
    timeDate = 4;
  }
  return timeDate
}


export const deViceOption4Bar = {
  tooltip: {
    trigger: "axis",
  },
  legend: {
    data: ["电力", "设定值", "均值"],
    top: 0,
    left: "center",
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    textStyle: {
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
      fontWeight: "bold",
    },
  },

  // 网格配置
  grid: {
    left: "3%",
    right: "8%",
    bottom: "8%",
    top: "20%",
    containLabel: true,
    containLabel: true,
  },

  // X轴配置
  xAxis: [
    {
      type: "category",
      name: "时间",
      nameTextStyle: {
        color: "white",
      },
      axisTick: {
        show: false,
      },
      axisLabel: {
        formatter: function (value) {
          return value;
        },
        rotate: 0,
        color: "white", // 设置为红色
        fontSize: 12, // 字体大小
      },
      axisLine: {
        lineStyle: {
          color: "#5D6A94",
        },
      },
      data: [],

    },
  ],

  // Y轴配置（双Y轴）
  yAxis: [
    {
      type: "value",
      min: 0,
      name: "单位:KW.h",
      axisLabel: {
        formatter: "{value}",
      },
      splitLine: {
        show: false,
      },
      axisLine: {
        lineStyle: {
          color: "#5D6A94",
        },
      },
      axisLabel: {
        formatter: function (value) {
          return value;
        },
        color: "white", // 设置为红色
        fontSize: 12, // 字体大小
      },
    },
  ],

  // 系列配置
  series: [
    {
      name: "电力",
      type: "bar",
      symbol: "circle",
      symbolSize: 0,
      data: [],
      barWidth: "50%",
      barMaxWidth: 18,
      itemStyle: {
        color: "#84CE30",
      },
      lineStyle: {
        color: "#19A3DF",
      },

      label: {
        show: false,
        color: "#FFBF28",
      },
      smooth: true,
    },

    // 第一条折线图（完成率）
    {
      name: "设定值",
      type: "line",
      data: [],
      itemStyle: {
        color: "#00FFF8",
      },
      symbol: "circle",
      symbolSize: 0,
      lineStyle: {
        width: 3,
      },
    },

    {
      name: "均值",
      type: "line",

      data: [],
      itemStyle: {
        color: "#EE6666",
      },
      symbolSize: 0,
      lineStyle: {
        width: 3,
      },
    },
  ],
}



export const deviceOptionLine4 = {
  tooltip: {
    trigger: "axis",
  },
  legend: {
    data: ["电力", "设定值", "均值"],
    top: 0,
    left: "center",
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    textStyle: {
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
      fontWeight: "bold",
    },
  },

  // 网格配置
  grid: {
    left: "3%",
    right: "8%",
    bottom: "8%",
    top: "20%",
    containLabel: true,
  },

  // X轴配置
  xAxis: [
    {
      type: "category",
      name: "时间",
      nameTextStyle: {
        color: "white",
      },
      axisTick: {
        show: false,
      },
      axisLabel: {
        formatter: function (value) {
          return value;
        },

        hideOverlap: true,
        color: "white", // 设置为红色
        fontSize: 12, // 字体大小
      },
      axisLine: {
        lineStyle: {
          color: "#5D6A94",
        },
      },
      data: [],

    },
  ],

  // Y轴配置（双Y轴）
  yAxis: [
    {
      type: "value",
      min: 0,
      name: "单位:KW.h",
      nameTextStyle: {
        color: "white",
      },
      axisLabel: {
        formatter: "{value}",
      },
      splitLine: {
        show: false,
      },
      axisLine: {
        lineStyle: {
          color: "#5D6A94",
        },
      },
      axisLabel: {
        formatter: function (value) {
          return value;
        },
        color: "white", // 设置为红色
        fontSize: 12, // 字体大小
      },
    },
  ],

  // 系列配置
  series: [
    {
      name: "电力",
      type: "line",
      symbol: "circle",
      symbolSize: 0,
      data: [],
      itemStyle: {
        color: "#84CE30",
      },
      lineStyle: {
        color: "#19A3DF",
      },
      areaStyle: {
        //区域填充样式
        normal: {
          //线性渐变，前4个参数分别是x0,y0,x2,y2(范围0~1);相当于图形包围盒中的百分比。如果最后一个参数是‘true’，则该四个值是绝对像素位置。
          color: new echarts.graphic.LinearGradient(
            0,
            0,
            0,
            1,
            [
              {
                offset: 0,
                color: "rgba(25,163,223,.3)",
              },
              {
                offset: 1,
                color: "rgba(25,163,223, 0)",
              },
            ],
            false
          ),
          shadowColor: "rgba(25,163,223, 0.5)", //阴影颜色
          shadowBlur: 20, //shadowBlur设图形阴影的模糊大小。配合shadowColor,shadowOffsetX/Y, 设置图形的阴影效果。
        },
      },
      label: {
        show: false,
        color: "#FFBF28",
      },
      smooth: true,
    },

    // 第一条折线图（完成率）
    {
      name: "设定值",
      type: "line",
      data: [],
      itemStyle: {
        color: "#00FFF8",
      },
      symbol: "circle",
      symbolSize: 0,
      lineStyle: {
        width: 3,
      },
    },

    {
      name: "均值",
      type: "line",

      data: [],
      itemStyle: {
        color: "#EE6666",
      },
      symbolSize: 0,
      lineStyle: {
        width: 3,
      },
    },
  ],
}

export const deviceOption4GuangBar = {
  legend: {
    data: ["用电量", "上网电量", "设定值", "均值"],
    top: 0,
    left: "center",
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    textStyle: {
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
      fontWeight: "bold",
    },
  },
  tooltip: {
    trigger: "axis",
  },
  grid: {
    left: "3%",
    right: "8%",
    bottom: "8%",
    top: "20%",
    containLabel: true,
  },
  xAxis: {
    type: "category",
    name: "时间",
    nameTextStyle: {
      color: "white",
      fontSize: 12,
    },
    data: [],

    axisLabel: {
      show: true,
      rotate: 0,
      // 避免空标签占用空间

      color: "white",
      fontSize: 12,
      hideOverlap: true
    },
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    axisTick: {
      show: false,
    },
  },
  yAxis: {
    type: "value",
    name: "单位:KW.h",
    // nameLocation: "start",

    nameTextStyle: {
      color: "white",
      fontSize: 12,
      padding: [0, 0, 0, 20],
    },
    axisLabel: {
      color: "white",
      fontSize: 12,
    },
    axisLine: {
      show: true,
      lineStyle: {
        color: "#5D6A94",
      },
    },
    splitLine: {
      show: false,
      lineStyle: {
        color: ["#1B2648"],
        width: 1,
        type: "dashed",
      },
    },
    axisTick: {
      show: true,
    },
  },
  series: [
    {
      name: "用电量",
      type: "line",
      symbol: "circle",
      symbolSize: 0,
      data: [],
      itemStyle: {
        color: "#1BB3F5",
      },
      lineStyle: {
        color: "#1BB3F5",
      },
      areaStyle: {
        //区域填充样式
        normal: {
          //线性渐变，前4个参数分别是x0,y0,x2,y2(范围0~1);相当于图形包围盒中的百分比。如果最后一个参数是‘true’，则该四个值是绝对像素位置。
          color: new echarts.graphic.LinearGradient(
            0,
            0,
            0,
            1,
            [
              {
                offset: 0,
                color: "rgba(25,163,223,.3)",
              },
              {
                offset: 1,
                color: "rgba(25,163,223, 0)",
              },
            ],
            false
          ),
          shadowColor: "rgba(25,163,223, 0.5)", //阴影颜色
          shadowBlur: 20, //shadowBlur设图形阴影的模糊大小。配合shadowColor,shadowOffsetX/Y, 设置图形的阴影效果。
        },
      },
      label: {
        show: false,
        color: "#FFBF28",
      },
      smooth: true,
    },
    {
      name: "上网电量",
      type: "line",
      symbol: "circle",
      symbolSize: 0,
      data: [],
      itemStyle: {
        color: "#78B029",
      },

      areaStyle: {
        //区域填充样式
        normal: {
          //线性渐变，前4个参数分别是x0,y0,x2,y2(范围0~1);相当于图形包围盒中的百分比。如果最后一个参数是‘true’，则该四个值是绝对像素位置。
          color: new echarts.graphic.LinearGradient(
            0,
            0,
            0,
            1,
            [
              {
                offset: 0,
                color: "rgba(25,163,223,.3)",
              },
              {
                offset: 1,
                color: "rgba(25,163,223, 0)",
              },
            ],
            false
          ),
          shadowColor: "rgba(25,163,223, 0.5)", //阴影颜色
          shadowBlur: 20, //shadowBlur设图形阴影的模糊大小。配合shadowColor,shadowOffsetX/Y, 设置图形的阴影效果。
        },
      },
      label: {
        show: false,
        color: "#FFBF28",
      },
      smooth: true,
    },

    // 第一条折线图（完成率）
    {
      name: "设定值",
      type: "line",
      data: [],
      itemStyle: {
        color: "#00FFFF",
      },
      symbol: "circle",
      symbolSize: 0,
      lineStyle: {
        width: 3,
      },
    },

    {
      name: "均值",
      type: "line",

      data: [],
      itemStyle: {
        color: "#EE6666",
      },
      symbolSize: 0,
      lineStyle: {
        width: 3,
      },
    },
  ],
}

export const option5Gas = {
  // 标题配置
  tooltip: {
    trigger: "axis",
    formatter: function (params) {
      // params 是数组，包含所有系列的数据
      let result = params[0].axisValue + '<br>';
      params.forEach(function (item) {
        // 使用系列的颜色作为小圆点
        const color = item.color;
        // 根据系列名称添加单位
        const unit = item.seriesName === '电力' || item.seriesName === '光伏' || item.seriesName === '燃气' ? ' t-CO₂' : '';
        result += `<span style="display:inline-block;margin-right:5px;border-radius:10px;width:10px;height:10px;background-color:${color};"></span>`;
        result += item.seriesName + ': ' + formatNumberText(item.value) + unit + '<br>';
      });
      return result;
    }
  },
  // 提示框配置
  grid: {
    left: "5%",
    right: "8%",
    top: "20%",
    bottom: "18%",
  },
  legend: {

    data: ['电力', '燃气'],
    top: 0,
    left: "center",
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    textStyle: {
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
      fontWeight: "bold",
    },
  },
  xAxis: {
    name: "时间",
    nameTextStyle: {
      color: "white",
    },
    type: "category",
    axisTick: {
      show: false,
    },
    axisLabel: {
      color: "white",
      fontWeight: 600,
    },
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    data: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"],
  },
  yAxis: {
    name: "单位:t-CO₂",
    nameTextStyle: {
      color: "white",
      padding: [0, 0, 0, 20],
      fontSize: 12,
    },
    type: "value",
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    axisLabel: {
      color: "white",
      fontWeight: 600,
      fontSize: 10,
    },
    splitLine: {
      show: false,
    },
  },
  series: [
    {
      name: "电力",
      data: [40, 26, 50, 80, 70, 60, 30, 40, 26, 50, 80, 40],
      label: {
        show: false,
        color: "white",

      },
      type: "bar",
      stack: "total",
      itemStyle: {
        color: "#78B029",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    }, {
      name: "燃气",
      data: [],
      label: {
        show: false,
        color: "white",

      },
      type: "bar",
      stack: "total",
      itemStyle: {
        color: "#00D3F6",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    },
  ]
}
export const option5Three = {
  // 标题配置
  tooltip: {
    trigger: "axis",
    formatter: function (params) {
      // params 是数组，包含所有系列的数据
      let result = params[0].axisValue + '<br>';
      params.forEach(function (item) {
        // 使用系列的颜色作为小圆点
        const color = item.color;
        // 根据系列名称添加单位
        const unit = item.seriesName === '电力' || item.seriesName === '光伏' || item.seriesName === '燃气' ? ' t-CO₂' : '';
        result += `<span style="display:inline-block;margin-right:5px;border-radius:10px;width:10px;height:10px;background-color:${color};"></span>`;
        result += item.seriesName + ': ' + formatNumberText(item.value) + unit + '<br>';
      });
      return result;
    }
  },
  // 提示框配置
  grid: {
    left: "5%",
    right: "8%",
    top: "20%",
    bottom: "18%",
  },
  legend: {
    data: ['电力', '燃气', '光伏'],
    top: 0,
    left: "center",
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    textStyle: {
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
      fontWeight: "bold",
    },
  },
  xAxis: {
    name: "时间",
    nameTextStyle: {
      color: "white",
    },
    type: "category",
    axisTick: {
      show: false,
    },
    axisLabel: {
      color: "white",
      fontWeight: 600,
    },
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    data: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"],
  },
  yAxis: {
    name: "单位:t-CO₂",
    nameTextStyle: {
      color: "white",
      padding: [0, 0, 0, 20],
      fontSize: 12,
    },
    type: "value",
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    axisLabel: {
      color: "white",
      fontWeight: 600,
      fontSize: 10,
    },
    splitLine: {
      show: false,
    },
  },
  series: [
    {
      name: "电力",
      data: [40, 26, 50, 80, 70, 60, 30, 40, 26, 50, 80, 40],
      label: {
        show: false,
        color: "white",

      },
      type: "bar",
      stack: "total",
      itemStyle: {
        color: "#78B029",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    }, {
      name: "燃气",
      data: [],
      label: {
        show: false,
        color: "white",

      },
      type: "bar",
      stack: "total",
      itemStyle: {
        color: "#00D3F6",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    }, {
      name: "光伏",
      data: [],
      label: {
        show: false,
        color: "white",

      },
      type: "bar",
      stack: "total",
      itemStyle: {
        color: "#F8F454",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    },
  ]
}
export const Indexoption5Three = {
  // 标题配置
  tooltip: {
    trigger: "axis",
    formatter: function (params) {
      // params 是数组，包含所有系列的数据
      let result = params[0].axisValue + '<br>';
      params.forEach(function (item) {
        // 使用系列的颜色作为小圆点
        const color = item.color;
        // 根据系列名称添加单位
        const unit = item.seriesName === '电力' || item.seriesName === '光伏' || item.seriesName === '燃气' ? ' t-CO₂' : '';
        result += `<span style="display:inline-block;margin-right:5px;border-radius:10px;width:10px;height:10px;background-color:${color};"></span>`;
        result += item.seriesName + ': ' + formatNumberText(item.value) + unit + '<br>';
      });
      return result;
    }
  },
  // 提示框配置
  grid: {
    left: "3%",
    right: "8%",
    top: "22%",
    bottom: "18%",
  },
  legend: {
    data: ['电力', '燃气'],
    top: 0,
    left: "center",
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    textStyle: {
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
      fontWeight: "bold",
    },
  },
  xAxis: {
    name: "时间",
    nameTextStyle: {
      color: "white",
    },
    type: "category",
    axisTick: {
      show: false,
    },
    axisLabel: {
      color: "white",
      fontWeight: 600,
    },
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    data: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"],
  },
  yAxis: {
    name: "单位:t-CO₂",
    nameTextStyle: {
      color: "white",
      padding: [0, 0, 0, 10],
      fontSize: 12,
    },
    type: "value",
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    axisLabel: {
      color: "white",
      fontWeight: 600,
      fontSize: 10,
    },
    splitLine: {
      show: false,
    },
  },
  series: [
    {
      name: "电力",
      data: [40, 26, 50, 80, 70, 60, 30, 40, 26, 50, 80, 40],
      label: {
        show: false,
        color: "white",

      },
      type: "bar",
      stack: "total",
      itemStyle: {
        color: "#78B029",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    }, {
      name: "燃气",
      data: [],
      label: {
        show: false,
        color: "white",

      },
      type: "bar",
      stack: "total",
      itemStyle: {
        color: "#00D3F6",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    },
  ]
}
export const option5Ele = {
  // 标题配置
  tooltip: {
    trigger: "axis",
    formatter: function (params) {
      // params 是数组，包含所有系列的数据
      let result = params[0].axisValue + '<br>';
      params.forEach(function (item) {
        // 使用系列的颜色作为小圆点
        const color = item.color;
        // 根据系列名称添加单位
        const unit = item.seriesName === '电力' || item.seriesName === '光伏' || item.seriesName === '燃气' ? ' t-CO₂' : '';
        result += `<span style="display:inline-block;margin-right:5px;border-radius:10px;width:10px;height:10px;background-color:${color};"></span>`;
        result += item.seriesName + ': ' + formatNumberText(item.value) + unit + '<br>';
      });
      return result;
    }
  },
  // 提示框配置
  grid: {
    left: "5%",
    right: "8%",
    top: "20%",
    bottom: "18%",
  },
  legend: {
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    data: ['电力'],
    top: 0,
    left: "center",
    textStyle: {
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
      fontWeight: "bold",
    },
  },
  xAxis: {
    name: "时间",
    nameTextStyle: {
      color: "white",
    },
    type: "category",
    axisTick: {
      show: false,
    },
    axisLabel: {
      color: "white",
      fontWeight: 600,
    },
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    data: [],
  },
  yAxis: {
    name: "单位:t-CO₂",
    nameTextStyle: {
      color: "white",

      fontSize: 12, padding: [0, 0, 0, 20],
    },
    type: "value",
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    axisLabel: {
      color: "white",
      fontWeight: 600,
      fontSize: 10,
      fontFamily: 'mei'
    },
    splitLine: {
      show: false,
    },
  },
  series: [
    {
      name: "电力",
      data: [],
      label: {
        show: false,
        color: "white",

        formatter: function (e) {
          if (e.data == 0) {
            return "";
          } else {
            return e.data;
          }
        },
      },
      type: "bar",

      itemStyle: {
        color: "#78B029",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    },

  ],
}

// 补全分钟数z自定义天的数据补全
export const completeTimeRange = function (startTimeStr, endTimeStr, defaultValue = 0, intervalMinutes = 15) {
  // 1. 解析开始和结束时间
  const startTime = new Date(startTimeStr.replace(' ', 'T') + ':00');
  const endTime = new Date(endTimeStr.replace(' ', 'T') + ':00');

  // 2. 调整起始时间的分钟数（如果不是 00 的倍数，则设为下一个 15 分钟）
  const startMinutes = startTime.getMinutes();
  if (startMinutes % intervalMinutes !== 0) {
    startTime.setMinutes(Math.ceil(startMinutes / intervalMinutes) * intervalMinutes);
  }

  // 3. 生成时间序列（每个时间点附带默认值）
  const timeSlots = [];
  let currentTime = new Date(startTime);

  while (currentTime <= endTime) {
    timeSlots.push([formatTime(currentTime), defaultValue]);
    currentTime = new Date(currentTime.getTime() + intervalMinutes * 60000);
  }

  return timeSlots;
}
function formatTime(date) {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  const hours = String(date.getHours()).padStart(2, '0');
  const minutes = String(date.getMinutes()).padStart(2, '0');
  return `${year}-${month}-${day} ${hours}:${minutes}`;
}


// 获取时间格式为00:00
export const getFormatHourTime = function (a) {
  const timeSlots = [];
  if (a == 3) {
    const now = new Date();
    const currentHour = now.getHours().toString().padStart(2, '0');

    // 生成24小时数组
    const timeSlots = Array.from({ length: 24 }, (_, i) => {
      const hour = i.toString().padStart(2, '0');
      return [hour + ':00', hour === currentHour ? 0 : 0];
    });

    return timeSlots;
  } else if (a == 4) {
    const now = new Date();
    let hour = now.getHours()
    const currentHour = now.getHours().toString().padStart(2, '0');

    // 生成24小时数组
    const timeSlots = Array.from({ length: hour + 1 }, (_, i) => {
      const hour = i.toString().padStart(2, '0');
      return [hour + ':00', hour === currentHour ? 0 : 0];
    });

    return timeSlots;
  }
  return timeSlots;
}


export const optionPie = {
  grid: { left: 0, right: 0 },
  tooltip: {
    trigger: "item",
    formatter: function (params) {
      // return params.data.name + "<br/>" + params.data.value;
    },
    // formatter: "{a} <br/>{b}: {c} ({d}%)",
  },
  series: [
    {
      name: "设备状态",
      type: "pie",
      // radius: ["65%", "90%"],
      avoidLabelOverlap: false,
      label: {
        show: false, // 默认不显示标签
        position: "center",
      },
      color: ["#E74A14", "#F8F454", "#00C659"],
      emphasis: {
        label: {
          show: false, // hover 时显示中心标签
          fontSize: 40,

          formatter: "{b}\n{d}%", // 自定义强调状态下的标签内容
        },
      },
      labelLine: {
        show: false,
      },
      data: [
        // { value: 200, name: "离线设备" },
        // { value: 200, name: "告警设备" },
        // { value: 200, name: "正常设备" },
      ],
    },
  ],
}

// 自动生成饼图

export const initPie = function (element, data) {
  const chart = echarts.init(element);
  console.log(element)
  let option = {
    grid: {
      left: '10%',
      right: '10%',
      top: '15%',
      bottom: '10%',
    },
    tooltip: {
      trigger: "item",
      formatter: function (params) {
        return params.data.name + "<br/>" + params.data.value;
      },
      position: function (point, params, dom, rect, size) {
        // point: 鼠标位置
        // params: 包含系列数据的对象
        // dom: tooltip 的 DOM 元素
        // rect: 图形元素矩形
        // size: 容器大小（包含 dom 的尺寸）

        // 设置 tooltip 在鼠标右侧
        var x = point[0] + 10; // 向右偏移 10px

        // 计算垂直居中位置
        var y = size.viewSize[1] / 2
        console.log(size)
        // 确保 tooltip 不会超出容器
        if (y < 0) y = 0;
        if (y + dom.offsetHeight > size.contentSize[1]) {
          y = size.viewSize[1] - dom.offsetHeight;
        }

        return [x, y];
      }
      // formatter: "{a} <br/>{b}: {c} ({d}%)",
    },
    series: [
      {
        name: "设备状态",
        type: "pie",
        // radius: ["65%", "90%"],
        avoidLabelOverlap: false,
        label: {
          show: false, // 默认不显示标签
          position: "center",
        },

        emphasis: {
          label: {
            show: false, // hover 时显示中心标签
            scaleSize: 1,

            formatter: "{b}\n{d}%", // 自定义强调状态下的标签内容
          },
        },
        labelLine: {
          show: false,
        },
        data: data
      },
    ],
  }
  chart.setOption(option);
}
export const IndexEle = {
  // 标题配置
  tooltip: {
    trigger: "axis",
  },
  // 提示框配置
  grid: {
    left: "3%",
    right: "8%",
    top: "20%",
    bottom: "18%",
  },
  legend: {
    itemWidth: 20,
    // 单个图例项的图标高度
    itemHeight: 12,
    data: ["电力", "燃气"],
    top: 0,
    left: "center",
    textStyle: {
      fontFamily: "mei",
      color: "white", // 设置为红色
      // 还可以设置其他文字样式
      fontSize: 12,
    },
  },
  xAxis: {
    name: "时间",
    nameTextStyle: {
      color: "white",
      fontFamily: "mei",
      fontSize: 12,
    },
    type: "category",
    axisTick: {
      show: false,
    },
    axisLabel: {
      color: "white",
      fontWeight: 600,
      fontFamily: "mei",
    },
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    data: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"],
  },
  yAxis: {
    name: "单位:t-CO₂",
    nameTextStyle: {
      color: "white",
      fontFamily: "mei",
      fontSize: 12,
      padding: [0, 0, 0, 10],
    },
    type: "value",
    axisLine: {
      lineStyle: {
        color: "#5D6A94",
      },
    },
    axisLabel: {
      color: "white",
      fontFamily: "mei",
      fontSize: 10,
    },
    splitLine: {
      show: false,
    },
  },

  series: [
    {
      name: "电力",
      data: [40, 26, 50, 80, 70, 60, 30, 40, 26, 50, 80, 40],
      label: {
        show: false,
        color: "white",
        formatter: function (e) {
          if (e.data == 0) {
            return "";
          } else {
          }
        },
      },
      type: "bar",
      stack: "total",
      itemStyle: {
        color: "#78B029",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    },
    {
      name: "燃气",
      data: [10, 50, 90, 40, 70, 80, 70, 10, 50, 90, 40, 70],
      label: {
        show: true,
        color: "white",
        formatter: function (e) {
          if (e.data == 0) {
            return "";
          } else {
            return e.data;
          }
        },
      },
      type: "bar",
      stack: "total",
      itemStyle: {
        color: "#00C0E0",
      },
      barWidth: "50%",
      barMaxWidth: 20,
    },
  ],
}








// 补全周

export const getWeekDateRange = function (yearWeek) {
  // 解析年份和周数
  const [year, week] = yearWeek.split('-').map(Number);

  // 获取当前日期
  const today = new Date();
  today.setHours(0, 0, 0, 0); // 清除时间部分
  const currentYear = today.getFullYear();
  const currentWeek = getWeekNumber(today);

  // 计算目标周的起始日期（周一）
  const targetWeekStart = getDateOfISOWeek(week, year);

  // 准备结果数组
  const result = [];

  // 计算该周的每一天（周一到周日）
  for (let i = 0; i < 7; i++) {
    const currentDate = new Date(targetWeekStart);
    currentDate.setDate(targetWeekStart.getDate() + i);
    const dateStr = formatDate(currentDate);

    // 判断日期状态
    let status = 0; // 默认状态

    // 如果是过去周或未来周，显示完整一周
    if (year < currentYear || (year === currentYear && week < currentWeek)) {
      result.push([dateStr, status]);
    }
    // 如果是当前周且日期在今天之后，不包含在结果中
    else if (year === currentYear && week === currentWeek && currentDate > today) {
      break; // 停止添加后续日期
    }
    // 如果是当前周且日期在今天或之前，添加到结果中
    else {
      result.push([dateStr, status, status, status]);
    }
  }

  return result;
}

/**
 * 获取指定ISO周数的周一日期
 * @param {number} week - 周数
 * @param {number} year - 年份
 * @returns {Date} 该周周一的日期对象
 */
function getDateOfISOWeek(week, year) {
  const date = new Date(year, 0, 1);
  const dayOfWeek = date.getDay();
  const dayDiff = (dayOfWeek <= 4 ? 1 - dayOfWeek : 8 - dayOfWeek);
  date.setDate(date.getDate() + dayDiff + (week - 1) * 7);
  return date;
}

/**
 * 获取指定日期的ISO周数
 * @param {Date} date - 日期对象
 * @returns {number} ISO周数
 */
function getWeekNumber(date) {
  const d = new Date(date);
  d.setHours(0, 0, 0, 0);
  d.setDate(d.getDate() + 3 - (d.getDay() + 6) % 7);
  const week1 = new Date(d.getFullYear(), 0, 4);
  return 1 + Math.round(((d - week1) / 86400000 - 3 + (week1.getDay() + 6) % 7) / 7);
}

/**
 * 格式化日期为 YYYY-MM-DD
 * @param {Date} date - 日期对象
 * @returns {string} 格式化后的日期字符串
 */
function formatDate(date) {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  return `${year}-${month}-${day}`;
}


// 处理选择月的数据返回


export const getMonthDates = function (monthStr) {
  // 解析年份和月份
  const [year, month] = monthStr.split('-').map(Number);

  // 获取当前日期
  const today = new Date();
  const currentYear = today.getFullYear();
  const currentMonth = today.getMonth() + 1; // 月份是0-11

  // 计算该月的天数
  const daysInMonth = new Date(year, month, 0).getDate();

  // 准备结果数组
  const result = [];

  // 确定要返回的天数
  let daysToReturn = daysInMonth;
  if (year === currentYear && month === currentMonth) {
    daysToReturn = today.getDate(); // 当前月只返回到今天
  }

  // 生成日期数组
  for (let day = 1; day <= daysToReturn; day++) {
    const dateStr = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
    result.push([dateStr, 0, 0, 0]);
  }

  return result;
}

// 补全一年的所有月份
export const getYearMonths = function (year) {
  // 转换为数字
  const yearNum = typeof year === 'string' ? parseInt(year, 10) : year;

  // 获取当前日期
  const today = new Date();
  const currentYear = today.getFullYear();
  const currentMonth = today.getMonth() + 1; // 月份是0-11

  // 确定要返回的月份数
  const monthsToReturn = yearNum === currentYear ? currentMonth : 12;

  // 准备结果数组
  const result = [];

  // 生成月份数组
  for (let month = 1; month <= monthsToReturn; month++) {
    const monthStr = `${yearNum}-${String(month).padStart(2, '0')}月`;
    result.push([monthStr, 0, 0, 0]);
  }

  return result;
}
export const arrEach = function (arr, arr1, arr2) {
  arr.forEach(item => {
    arr1.push(item[0]);
    arr2.push(item[1]);
  })
}
export const arrEachsingle = function (arr, arr1) {
  arr.forEach(item => {
    arr1.push(item[1]);
  })
}
export const arrEachThree = function (arr, arr1, arr2, arr3) {
  arr.forEach(item => {
    arr1.push(item[0]);
    arr2.push(item[1]);
    arr3.push(item[2])
  })
}
export const arrEachfour = function (arr, arr1, arr2, arr3, arr4) {
  arr.forEach(item => {
    arr1.push(item[0]);
    arr2.push(item[1]);
    arr3.push(item[2])
    arr4.push(item[3])
  })
}



// 用能分析页面获取当前时间的函数

export const userEnengy = function () {
  const now = new Date();
  let hour = now.getHours()
  const currentHour = now.getHours().toString().padStart(2, '0');

  // 生成24小时数组
  const timeSlots = Array.from({ length: hour + 1 }, (_, i) => {
    let hour = i.toString().padStart(2, '0');
    hour = hour + ':00'
    return [hour, hour === currentHour ? 0 : 0];
  });

  return timeSlots;

}

export const arrEachOne = function (arr, arr1) {
  arr.forEach(item => {
    arr1.push(item[0]);
  })
}




export const deilWith = function (item, arr, time, axisTime, number) {
  axisTime = [];
  number = [];
  if (item.timeValueList && item.timeValueList.length > 0) {
    item.timeValueList.forEach((it) => {
      arr.push([it.time, it.value]);
    });
    arr = completeMissingTimes(time, arr);

    arr.forEach((item) => {
      axisTime.push(item[0]);
      number.push(item[1]);
    });
    console.log(number);
  } else {
    arrEachsingle(time, number);
    arrEachsingle(time, axisTime);
    console.log(axisTime);
  }

}



// 数组累加结果

export const sumArrayElements = function (arr) {
  if (!Array.isArray(arr) || arr.length === 0) {
    return 0;
  }

  const sum = arr.reduce((total, current) => {
    // 处理 null
    if (current === null) {
      return total + 0;
    }

    // 处理字符串数字（包括整数、小数）
    if (typeof current === 'string' && !isNaN(current)) {
      return total + parseFloat(current);
    }

    // 处理数字
    if (typeof current === 'number') {
      return total + current;
    }

    // 其他情况（非数字、非字符串数字、非 null）忽略
    return total;
  }, 0);

  // 保留最多两位小数，并转为数字（避免返回字符串）
  return parseFloat(sum.toFixed(2));
}




// 用于判断当月日期并去除周末日期

export const getMonthWithoutWeek = function (data) {
  // 解析输入的年月（如 '2025-08'）
  const [yearStr, monthStr] = data.split("-");
  const year = parseInt(yearStr, 10);
  const month = parseInt(monthStr, 10) - 1; // 月份是 0-11（0=January）

  // 获取当前日期（用于判断是否只返回到今天）
  const now = new Date();
  const currentYear = now.getFullYear();
  const currentMonth = now.getMonth();
  const currentDay = now.getDate();

  // 判断传入的月份是否是当前月
  const isCurrentMonth = year === currentYear && month === currentMonth;

  // 获取该月的天数
  const daysInMonth = new Date(year, month + 1, 0).getDate();

  const result = [];

  // 遍历该月的每一天
  for (let day = 1; day <= daysInMonth; day++) {
    // 如果是当前月，且超过今天，则跳过
    if (isCurrentMonth && day > currentDay) {
      continue;
    }

    const date = new Date(year, month, day);
    const dayOfWeek = date.getDay(); // 0=Sunday, 1=Monday, ..., 6=Saturday

    // 跳过周六 (6) 和周日 (0)
    if (dayOfWeek === 0 || dayOfWeek === 6) {
      continue;
    }

    // 格式化日期为 'YYYY-MM-DD'（补零）
    const formattedDate = `${year}-${String(month + 1).padStart(
      2,
      "0"
    )}-${String(day).padStart(2, "0")}`;
    result.push([formattedDate, 0]);
  }

  return result;
}

// 获取用能分析的月份

export const formatYearMonths = function (yearStr) {
  const currentDate = new Date();
  const currentYear = currentDate.getFullYear();
  const currentMonth = currentDate.getMonth() + 1; // 1-12

  const inputYear = parseInt(yearStr, 10);
  const isCurrentYear = inputYear === currentYear;

  const result = [];
  const endMonth = isCurrentYear ? currentMonth : 12;

  for (let month = 1; month <= endMonth; month++) {
    const formattedMonth = String(month).padStart(2, '0');
    result.push([`${inputYear}-${formattedMonth}`, 0]);
  }

  return result;
}
// s首页大屏保留的optionBar
// optionBar: {
//   tooltip: {
//     trigger: "axis",
//   },
//   legend: {
//     data: ["总功率"],
//     top: 0,
//     left: "center",
//     itemWidth: 20,
//     // 单个图例项的图标高度
//     itemHeight: 12,
//     textStyle: {
//       fontFamily: "mei",
//       color: "white", // 设置为红色
//       // 还可以设置其他文字样式
//       fontSize: 12,
//       fontWeight: "bold",
//     },
//   },
//   grid: {
//     top: "15%",
//     left: "3%",
//     right: "8%",
//     bottom: "5%",
//     containLabel: true,
//   },
//   xAxis: {
//     name: "时间",
//     nameTextStyle: {
//       color: "white",
//       fontFamily: "mei",
//       fontSize: 12,
//     },
//     data: [],
//     axisLine: {
//       lineStyle: {
//         color: "#5D6A94",
//       },
//     },
//     axisLabel: {
//       formatter: function (value) {
//         return value;
//       },
//       color: "#fff",
//       fontSize: 12,
//       rotate: 0,
//       fontFamily: "mei",
//     },
//   },
//   yAxis: {
//     name: "单位:KW.h",
//     nameTextStyle: {
//       color: "white",
//       fontFamily: "mei",
//       fontSize: 12,
//     },
//     axisLine: {
//       lineStyle: {
//         color: "#5D6A94",
//       },
//     },
//     axisLabel: {
//       color: "#fff",
//       fontSize: 12,
//       fontFamily: "mei",
//     },
//     splitLine: {
//       show: false,
//       lineStyle: {
//         color: "#0177d4",
//       },
//     },
//   },
//   series: [
//     {
//       type: "bar",
//       name: "总功率",
//       barWidth: 18,
//       itemStyle: {
//         normal: {
//           color: new echarts.graphic.LinearGradient(
//             0,
//             0,
//             0,
//             1,
//             [
//               {
//                 offset: 0,
//                 color: "#00b0ff",
//               },
//               {
//                 offset: 0.8,
//                 color: "#7052f4",
//               },
//             ],
//             false
//           ),
//         },
//       },
//       data: [],
//     },
//   ],
// },



// 分组大屏的option1之前所用的
// optionBar: {
//   tooltip: {
//     trigger: "item",
//   },
//   legend: {
//     data: ["总功耗"],
//     itemWidth: 20,
//     // 单个图例项的图标高度
//     itemHeight: 12,
//     textStyle: {
//       color: "white", // 设置为红色
//       // 还可以设置其他文字样式
//       fontSize: 12,
//       fontWeight: "bold",
//     },
//   },
//   grid: {
//     top: "18%",
//     left: "3%",
//     right: "8%",
//     bottom: "5%",
//     containLabel: true,
//   },
//   xAxis: {
//     name: "时间",
//     nameTextStyle: {
//       color: "white",
//       fontFamily: "mei",
//       fontSize: 12,
//     },
//     data: [],
//     axisLine: {
//       lineStyle: {
//         color: "#5D6A94",
//       },
//     },
//     axisLabel: {
//       formatter: function (value) {
//         return value;
//       },

//       color: "#fff",
//       fontFamily: "mei",
//       fontSize: 12,
//       rotate: 0,
//     },
//   },
//   yAxis: {
//     name: "单位:(KW.h)",
//     nameTextStyle: {
//       color: "white",
//       fontFamily: "mei",
//       fontSize: 12,
//     },
//     axisLine: {
//       lineStyle: {
//         color: "#5D6A94",
//       },
//     },
//     axisLabel: {
//       color: "#fff",
//       fontSize: 12,
//       fontFamily: "mei",
//     },
//     splitLine: {
//       show: false,
//       lineStyle: {
//         color: "#0177d4",
//       },
//     },
//   },
//   series: [
//     {
//       type: "bar",
//       barWidth: 18,
//       itemStyle: {
//         normal: {
//           color: new echarts.graphic.LinearGradient(
//             0,
//             0,
//             0,
//             1,
//             [
//               {
//                 offset: 0,
//                 color: "#00b0ff",
//               },
//               {
//                 offset: 0.8,
//                 color: "#7052f4",
//               },
//             ],
//             false
//           ),
//         },
//       },
//       data: [],
//     },
//   ],
// },
// optionDay: {
//   tooltip: {
//     trigger: "axis",
//     formatter: function (params) {
//       const currentIndex = params[0].dataIndex;
//       // seriesName;
//       let result =
//         params[0].axisValue +
//         "<br/>" +
//         params[0].seriesName +
//         ":" +
//         params[0].value +
//         "<br/>";
//       let sum = 0;

//       for (let i = 0; i < currentIndex + 1; i++) {
//         const item = totalNumber[i];
//         // 将 null 视为 0
//         if (item === null) {
//           sum += 0;
//           continue;
//         }
//         // 尝试转换为数字
//         const num = Number(item);
//         // 只有是有效数字才累加
//         if (!isNaN(num)) {
//           sum += num;
//         }
//       }

//       result += `累计值: ${sum.toFixed(2)}`;
//       return result;
//     },
//   },
//   legend: {
//     data: ["总功耗"],
//     itemWidth: 20,
//     // 单个图例项的图标高度
//     itemHeight: 12,
//     textStyle: {
//       color: "white", // 设置为红色
//       // 还可以设置其他文字样式
//       fontSize: 12,
//       fontWeight: "bold",
//     },
//   },
//   grid: {
//     top: "18%",
//     left: "3%",
//     right: "8%",
//     bottom: "5%",
//     containLabel: true,
//   },
//   xAxis: {
//     type: "category",
//     name: "时间",
//     nameTextStyle: {
//       color: "white",
//       fontFamily: "mei",
//       fontSize: 12,
//     },
//     data: [],

//     axisLabel: {
//       formatter: function (value) {
//         return value;
//       },
//       rotate: 45,
//       fontFamily: "mei",
//       // 避免空标签占用空间
//       interval: 0,
//       color: "white",
//       fontSize: 12,
//     },
//     axisLine: {
//       lineStyle: {
//         color: "#5D6A94",
//       },
//     },
//     axisTick: {
//       show: false,
//     },
//   },
//   yAxis: {
//     type: "value",
//     name: "单位:(KW.h)",
//     nameTextStyle: {
//       color: "white",
//       fontFamily: "mei",
//       fontSize: 12,
//     },

//     axisLabel: {
//       color: "white",
//       fontSize: 12,
//       fontFamily: "mei",
//     },
//     axisLine: {
//       show: true,
//       lineStyle: {
//         color: "#5D6A94",
//       },
//     },

//     splitLine: {
//       show: false,
//       lineStyle: {
//         color: ["#1B2648"],
//         width: 1,
//         type: "dashed",
//       },
//     },
//     axisTick: {
//       show: true,
//     },
//   },
//   series: [
//     {
//       name: "总功耗",
//       type: "line",
//       symbol: "circle",
//       symbolSize: 0,
//       z: 1,

//       itemStyle: {
//         color: "#19A3DF",
//         borderColor: "white", // 边框颜色
//         borderWidth: 2, // 边框宽度
//         borderType: "solid",
//       },
//       lineStyle: {
//         color: "#19A3DF",
//       },
//       label: {
//         show: false,
//         color: "#FFBF28",
//       },
//       labelLayout: { hideOverlap: true },
//       data: [
//         0.55, 0.15, 0.28, 0.84, 0.33, 0.15, 0.95, 0.18, 0.84, 0.83, 0.55,
//         0.55, 0.15, 0.28, 0.83, 0.55, 0.65, 0.78, 0.84, 0.83, 0.15, 0.28,
//         0.84, 0.33,
//       ],
//       areaStyle: {
//         //区域填充样式
//         normal: {
//           //线性渐变，前4个参数分别是x0,y0,x2,y2(范围0~1);相当于图形包围盒中的百分比。如果最后一个参数是‘true’，则该四个值是绝对像素位置。
//           color: new echarts.graphic.LinearGradient(
//             0,
//             0,
//             0,
//             1,
//             [
//               {
//                 offset: 0,
//                 color: "rgba(25,163,223,.3)",
//               },
//               {
//                 offset: 1,
//                 color: "rgba(25,163,223, 0)",
//               },
//             ],
//             false
//           ),
//           shadowColor: "rgba(25,163,223, 0.5)", //阴影颜色
//           shadowBlur: 20, //shadowBlur设图形阴影的模糊大小。配合shadowColor,shadowOffsetX/Y, 设置图形的阴影效果。
//         },
//       },
//       smooth: true,
//     },
//   ],
// },